Reference for bindings expressions

Here you can find the reference for the bindings expressions you can add to the bindings of your objects, styles, and state managers. See Using styles and State managers.

You can create bindings after you add the Bindings property to a node. Blue type marks the properties that are controlled by a binding.

When creating bindings, note that:

• Only bindings to similar data types are valid. For example, you can bind only color to color, vector2 to vector2, and so on.
• Binding takes the value of the last expression, whether it is an assignment, unary or binary operation, or just a constant value or variable itself.
• In bindings you can cast strings between the four fundamental types: integer, float, boolean, and string. Casts between integer, float, and boolean are implicit and depend on the type of the property that uses the value. Casts to and from string are explicit.

Syntax

# (comments)

Use a hash at the beginning of every line that contains a comment. You can use any sequence of characters in comments.

# This is a comment, so you can describe your binding expressions
# Calculate the value of A
A = (2 + 4) / 3

() (parentheses)

Use parentheses to group and contain expressions and parameters, and control the order of execution.

# Containing expressions: calculate the modulo of two values
MOD(23, 27)

# Grouping expressions: first add 2 and 4, then divide the result by 3,
# and return 2
A = (2 + 4) / 3

# First add FOV property to Render Transformation property attribute Scale X,
# then divide the result of the multiplication by 2
({../Camera/Fov} + {../Box/RenderTransformation}.ScaleX) / 2

= (assign)

Assigns a value to a variable.

# Assigns the value 2.0 to the variable 'A'
A = 2.0

# Assigns the value 4.0 to the variable 'B'
B = 4.0

Operators

+ (addition)

Adds two or more values, or combines strings into one.

A = 2.0
B = 4.0

# Returns 6.0
A + B

- (subtraction)

Subtracts the value of the second parameter from the value of the first parameter. As a negation operator, it returns the result equivalent to multiplying the value by -1.

A = 2.0
B = 4.0

# Returns -2.0
A - B

* (multiplication)

Multiplies the values of parameters.

A = 2.0
B = 4.0

# Returns 8.0
A * B

/ (division)

Divides the value of the first parameter by the value of the second parameter.

A = 2.0
B = 4.0

# Returns 0.5
A / B

Casting

Casts between integer, float, and boolean are implicit and depend on the type of the property that uses the value. Casts to and from string are explicit.

Integer

Converts a value to an integer. Casts between integer, float, and boolean are implicit and depend on the type of the property that uses the value. Casts to and from string are explicit.

# Explicitly converts the string "5" to an integer, adds it to the integer 5,
# and assigns the result to the variable A. Returns integer 10.
A = 5 + INT("5")

# Implicitly converts boolean value True to integer, adds it to the integer 5,
# and assigns the result to the variable A. Returns integer 6.
B = 5 + True

# Explicitly converts float 5.5 to an integer, adds it to the integer and
# assigns the result to the variable C. Returns integer 7.
C = 2 + INT(5.5)

Float

Converts a value to a float. Casts between integer, float, and boolean are implicit and depend on the type of the property that uses the value. Casts to and from string are explicit.

# Converts the string "5" to a float, adds it to the integer 5,
# and assigns the result to the variable A. Returns float 10.000000.
A = 5 + FLOAT("5")

# Implicitly converts boolean value True to float, adds it to the float 5.1,
# and assigns the result to the variable A. Returns float 6.1.
B = 5.1 + True

Boolean

Converts a value to a boolean. Casts between integer, float, and boolean are implicit and depend on the type of the property that uses the value. Casts to and from string are explicit.

# Converts the string value "True" to a boolean, adds it to the integer 5,
# and assigns the result to the variable A. Returns integer 6.
A = 5 + BOOL("True")

String

Converts a value to a string. Casts between integer, float, and boolean are implicit and depend on the type of the property that uses the value. Casts to and from string are explicit.

# Converts the integer 5 to a string, concatenates it to the string
# "Five is written as ", and assigns the result to the variable B.
# Returns string "Five is written as 5".
A = "Five is written as " + STRING(5)

# Converts the value of the variable A to a string, concatenates it
# to the string "Number of fingers on two hands is ", and assigns the result
# to the variable B. Returns string "Number of fingers on two hands is 10".
A = 10
C = "Number of fingers on two hands is " + STRING(A)

Functions

Absolute value

Calculates the absolute value of a number or a variable. The absolute value of a number is always positive.

# Returns 5.2
ABS(-5.2)

Animate

Binds a property value to a piecewise function that you define in an Animation Data item. See Using piecewise functions in bindings.

Animate takes two arguments: the property to which you are binding the Animation Data item, and the resource ID of the Animation Data item where you define the piecewise function you want to use to set the value of the bound property. You have to place the Animation Data item to the resource dictionary where the object containing the binding can access it. See Using local and global resources.

For example, you can use the Animate function to set how quickly a needle in a gauge moves: you can set the needle to move faster from values 0 to 100 than it does for values from 100 to 250.

# Uses the Position property to move along the animation curve
# of the Animation Data item with the resource ID Speed curve.
Animate({@./Position}, "Speed curve")

Ceil

Calculates the closest integer value that is greater than or equal to the value of the parameter.

# Returns 3.0
CEIL(2.06)

# Returns 16.0
CEIL(15.92)

Clamp

Constrains a value to lie between two values. CLAMP returns the same value as MIN(MAX(value, low), high).

# Returns 1
CLAMP(1, 4, 0.5)

# Returns 4
CLAMP(-3, 8, 4)

Floor

Calculates the closest integer value that is less than or equal to the value of the parameter.

# Returns 0
FLOOR(0.8)

# Returns 1
FLOOR(1.5)

# Returns 15
FLOOR(15.92)

Linear step

Performs linear interpolation between two values. LINEARSTEP returns the same value as CLAMP(0, 1 (value - low) / (high - low)).

# Returns 0.0
LINEARSTEP(1, 4, 0.5)

# Returns 0.64 (7/11)
LINEARSTEP(-3, 8, 4)

Max

Determines the larger of the two values and returns the larger value.

# Returns 5
MAX(2, 5)

# Returns -2.1
MAX(-10, -2.1)

Min

Determines the smaller of the two values and returns the smaller value.

# Returns 2
MIN(2, 5)

# Returns -10
MIN(-10, -2.1)

Mix

Performs a linear interpolation between two values using a value to weight between them. Kanzi computes the result using this function: (end - start) * weight + start.

# Returns 2.5
MIX(1, 4, 0.5)

# Returns 0.5
MIX(-1, -4, -0.5)

Modulo

Calculates the remainder when one number is divided by another. MOD() takes a division as a parameter and returns the remainder.

# Returns 2.1
MOD(12.1, 5)

# Returns 23
MOD(23, 27)

Power

Calculates exponential expressions. It is an efficient way for multiplying numbers by themselves.

# Is equivalent to 2*2*2*2*2 and returns 32
POW(2, 5)

Round

Calculates the closest integer.

# Returns 1.0
ROUND(0.8)

# Returns 2.0
ROUND(1.5)

# Returns 0.0
ROUND(0.1)

Square root

Calculates the square root of a number. The square root value of a number is always positive.

# Returns 5.0
SQRT(25)

Step

Compares a value to a threshold.

# Returns 1.0
STEP(2, 5)

# Returns 0.0
STEP(0.0, -0.1)

# Returns 1.0
STEP(1.0, 1.0)

Common binding expressions

Constants

To bind a property value to a constant, enter just the constant.

# Binds the value of the selected property to 10.
10

Variables

In binding expressions you can use variables.

# Assigns the value 1 to the variable 'A', and binds the value of
# the variable to the selected property.
A = 1

# Same as above, but using an alternative syntax.
A = (1)

Property bindings

To bind a property to another property, enter in curly braces the @ sign followed by the relative path to the object, followed by a forward slash and source property name.

When you use the @ sign before the path, Kanzi Studio updates the binding expression whenever the location between the source and the target object in the scene graph changes. Note that with the @ sign you can create bindings only within the same prefab, not between prefabs.

You can drag property names from the Properties to the Binding Argument Editor.

You can use the operators and parentheses with property values and property attribute values.

# Binds to property Layout Width of the current object.
{@./LayoutWidth}

# Binds to the property FOV of the Camera object.
{@../Camera/Fov}

# Same as above, but Kanzi Studio does not track the location of the target object.
{../Camera/Fov}

# Binds to the property Vertical Margin of the Box object
{@../Box/LayoutVerticalMargin}

# Multiplies the FOV property with the Layout Transformation property attribute Scale X.
{@../Camera/Fov} * {../Box/LayoutTransformation}.ScaleX

Alias bindings

To bind a property to an alias, enter in curly braces the # sign followed by the alias name, followed by a forward slash and property name of the alias' target. See Using aliases.

# Binds to the Layout Width property of the target object of the alias named Sphere.
{#Sphere/LayoutWidth}

# Multiplies the FOV property of the target object of the alias named MainCamera
# with the Render Transformation property attribute Scale X.
{#MainCamera/Fov} * {../Box/RenderTransformation}.ScaleX

Attribute bindings

To bind a property to object's property common attribute, enter in curly braces the relative path to the object, followed by a forward slash and property name, followed by a period and attribute name. For property attributes that are not common, instead of the attribute name use VectorN, where N is X, Y, Z, or W denoting the order in which the property is listed in the Properties. You can use the operators and parentheses with property values and property attribute values.

When you want to bind a property to an attribute use the following attributes.

# Binds to the attribute Scale X (value of the Scale X attribute)
# of the Box node's Layout Transformation property.
{../Box/LayoutTransformation}.ScaleX

# Binds to the attribute Color R (value of the red color channel)
# of the Point Light node's Point Light Color property.
{../Point Light/PointLightColor}.ColorR

# Light objects have an attenuation property that has three attributes:
# Constant, Linear, and Quadratic.
# For example, for the Point Light:
# To bind to the first attribute (Constant)
{../Light/PointLightAttenuation}.VectorX

# To bind to the second attribute (Linear)
{../Light/PointLightAttenuation}.VectorY

# To bind to the third attribute (Quadratic)
{../Light/PointLightAttenuation}.VectorZ

# Multiply property FOV with Render Transformation property attribute Scale X.
{../Camera/Fov} * {../Box/RenderTransformation}.ScaleX

Color attribute bindings

Color4()binds color attributes. Color4() takes four arguments: the first specifies the value for the red color channel, the second specifies the value for the green color channel, the third specifies the value for the blue color channel, and the fourth specifies the value for the alpha channel. Color values are mapped to the range 0..1.

# Sets the color to white and opaque.
Color4(1, 1, 1, 1)

# Same as above, but with alternative syntax.
Color(1, 1, 1, 1)

# Sets the color to red with 50% transparency.
Color4(1, 0, 0, 0.5)

# Invalid expression, one argument is missing.
Color4(0.1, 1, 0.4)

# Use variables as attributes of the Color4() to assign the
# attribute values of the whole Color property.
#
# Assigns custom properties Red, Green, and Blue to variables
# you use to control the color of an object.
red = {@./Red}
green = {@./Green}
blue = {@./Blue}
color = Color4(0, 0, 0, 1)
# Assigns the red, green, and blue variables to each color channel attribute.
color.ColorR = red
color.ColorG = green
color.ColorB = blue
color

Transformation attribute bindings

MatrixSRT() binds transformation attributes. MatrixSRT() takes nine arguments: the first three arguments specify the scale transformation, the second three arguments specify the rotation transformation, and the last three arguments specify the translation transformation.

# Scales the object on the x, y, and z axes to 1 unit,
# rotates it around the x axis by 30 degrees
# and moves it on the z axis by 2 units.
MatrixSRT(1, 1, 1, 30, 0, 0, 0, 0, 2)

# Use variables as attributes of the MatrixSRT() to assign the
# attribute values of the whole Render Transformation property.

# Assigns custom property Rotation to a variable you use to control
# the rotation of an object.
rotate = {@./Rotation}
position = MatrixSRT(1, 1, 1, 0, 0, 0, 0, 0, 0)

# Assigns the rotation variable to each rotation attribute.
position.RotationX = rotate
position.RotationY = rotate
position.RotationZ = rotate
position

See also

Using bindings

Using aliases

Open topic with navigation